રેફરન્સ કાઉન્ટિંગ અલ્ગોરિધમ્સ: સાયક્લિક ગાર્બેજ કલેક્શનનો અમલ

રેફરન્સ કાઉન્ટિંગ એ મેમરી મેનેજમેન્ટ તકનીક છે જ્યાં મેમરીમાં દરેક ઓબ્જેક્ટ તેની તરફ નિર્દેશ કરતી સંદર્ભોની સંખ્યા જાળવી રાખે છે. જ્યારે ઓબ્જેક્ટનો રેફરન્સ કાઉન્ટ શૂન્ય થઈ જાય છે, ત્યારે તેનો અર્થ એ છે કે અન્ય કોઈ ઓબ્જેક્ટ તેનો સંદર્ભ આપી રહ્યા નથી, અને ઓબ્જેક્ટને સુરક્ષિત રીતે ડીએલોકેટ કરી શકાય છે. આ અભિગમ અનેક ફાયદાઓ પ્રદાન કરે છે, પરંતુ તે પડકારોનો પણ સામનો કરે છે, ખાસ કરીને સાયક્લિક ડેટા સ્ટ્રક્ચર્સ સાથે. આ લેખ રેફરન્સ કાઉન્ટિંગ, તેના ફાયદા, મર્યાદાઓ અને સાયક્લિક ગાર્બેજ કલેક્શનના અમલીકરણ માટેની વ્યૂહરચનાઓની વ્યાપક ઝાંખી પૂરી પાડે છે.

રેફરન્સ કાઉન્ટિંગ શું છે?

રેફરન્સ કાઉન્ટિંગ એ ઓટોમેટિક મેમરી મેનેજમેન્ટનો એક પ્રકાર છે. મેમરીમાં ન વપરાયેલ ઓબ્જેક્ટ્સને શોધવા માટે સમયાંતરે મેમરીને સ્કેન કરવા માટે ગાર્બેજ કલેક્ટર પર આધાર રાખવાને બદલે, રેફરન્સ કાઉન્ટિંગનો ઉદ્દેશ્ય મેમરીને પહોંચી વળી શકાય તેવું ન બને તેટલું જલદી પુનઃપ્રાપ્ત કરવાનો છે. મેમરીમાં દરેક ઓબ્જેક્ટનો એક સંબંધિત રેફરન્સ કાઉન્ટ હોય છે, જે તે ઓબ્જેક્ટના સંદર્ભો (પોઇન્ટર્સ, લિંક્સ, વગેરે) ની સંખ્યા દર્શાવે છે. મૂળભૂત કામગીરીઓ છે:

• રેફરન્સ કાઉન્ટમાં વધારો: જ્યારે કોઈ ઓબ્જેક્ટનો નવો સંદર્ભ બનાવવામાં આવે છે, ત્યારે ઓબ્જેક્ટના રેફરન્સ કાઉન્ટમાં વધારો થાય છે.
• રેફરન્સ કાઉન્ટમાં ઘટાડો: જ્યારે કોઈ ઓબ્જેક્ટનો સંદર્ભ દૂર કરવામાં આવે છે અથવા સ્કોપની બહાર જાય છે, ત્યારે ઓબ્જેક્ટના રેફરન્સ કાઉન્ટમાં ઘટાડો થાય છે.
• ડીએલોકેશન: જ્યારે ઓબ્જેક્ટનો રેફરન્સ કાઉન્ટ શૂન્ય સુધી પહોંચે છે, ત્યારે તેનો અર્થ એ છે કે પ્રોગ્રામના અન્ય કોઈ ભાગ દ્વારા ઓબ્જેક્ટનો સંદર્ભ આપવામાં આવી રહ્યો નથી. આ સમયે, ઓબ્જેક્ટને ડીએલોકેટ કરી શકાય છે, અને તેની મેમરી પુનઃપ્રાપ્ત કરી શકાય છે.

ઉદાહરણ: Python માં એક સરળ દ્રશ્યનો વિચાર કરો (જોકે Python મુખ્યત્વે ટ્રેસિંગ ગાર્બેજ કલેક્ટરનો ઉપયોગ કરે છે, તે તાત્કાલિક સફાઈ માટે રેફરન્સ કાઉન્ટિંગનો પણ ઉપયોગ કરે છે):

obj1 = MyObject()
obj2 = obj1  # obj1 ના રેફરન્સ કાઉન્ટમાં વધારો
del obj1  # MyObject ના રેફરન્સ કાઉન્ટમાં ઘટાડો; obj2 દ્વારા ઓબ્જેક્ટ હજુ પણ સુલભ છે
del obj2  # MyObject ના રેફરન્સ કાઉન્ટમાં ઘટાડો; જો આ છેલ્લો સંદર્ભ હતો, તો ઓબ્જેક્ટ ડીએલોકેટ થાય છે

રેફરન્સ કાઉન્ટિંગના ફાયદા

રેફરન્સ કાઉન્ટિંગ ટ્રેસિંગ ગાર્બેજ કલેક્શન જેવી અન્ય મેમરી મેનેજમેન્ટ તકનીકો કરતાં અનેક નોંધપાત્ર ફાયદાઓ પ્રદાન કરે છે:

• તાત્કાલિક પુનઃપ્રાપ્તિ: જ્યારે કોઈ ઓબ્જેક્ટ પહોંચી શકાય તેવું ન રહે ત્યારે મેમરી પુનઃપ્રાપ્ત થાય છે, મેમરી ફૂટપ્રિન્ટ ઘટાડે છે અને પરંપરાગત ગાર્બેજ કલેક્ટર્સ સાથે સંકળાયેલા લાંબા વિરામથી બચાવે છે. આ નિર્ધારિત વર્તન ખાસ કરીને રીઅલ-ટાઇમ સિસ્ટમ્સ અથવા કડક પ્રદર્શન આવશ્યકતાઓવાળી એપ્લિકેશન્સ માટે ઉપયોગી છે.
• સરળતા: મૂળભૂત રેફરન્સ કાઉન્ટિંગ અલ્ગોરિધમ અમલ કરવા માટે પ્રમાણમાં સરળ છે, જે તેને એમ્બેડેડ સિસ્ટમ્સ અથવા મર્યાદિત સંસાધનોવાળા વાતાવરણ માટે યોગ્ય બનાવે છે.
• સંદર્ભની સ્થાનિકતા: ઓબ્જેક્ટને ડીએલોકેટ કરવાથી ઘણીવાર તે સંદર્ભિત કરતા અન્ય ઓબ્જેક્ટ્સનું ડીએલોકેશન થાય છે, કેશ પ્રદર્શન સુધારે છે અને મેમરી ફ્રેગ્મેન્ટેશન ઘટાડે છે.

રેફરન્સ કાઉન્ટિંગની મર્યાદાઓ

તેના ફાયદાઓ હોવા છતાં, રેફરન્સ કાઉન્ટિંગ અનેક મર્યાદાઓથી પીડાય છે જે ચોક્કસ પરિસ્થિતિઓમાં તેની વ્યવહારિકતાને અસર કરી શકે છે:

• ઓવરહેડ: રેફરન્સ કાઉન્ટ્સમાં વધારો અને ઘટાડો નોંધપાત્ર ઓવરહેડ દાખલ કરી શકે છે, ખાસ કરીને વારંવાર ઓબ્જેક્ટ બનાવટ અને કાઢી નાખવાની સિસ્ટમ્સમાં. આ ઓવરહેડ એપ્લિકેશન પ્રદર્શનને અસર કરી શકે છે.
• સર્ક્યુલર રેફરન્સ: મૂળભૂત રેફરન્સ કાઉન્ટિંગની સૌથી નોંધપાત્ર મર્યાદા સર્ક્યુલર રેફરન્સને હેન્ડલ કરવામાં તેની અસમર્થતા છે. જો બે અથવા વધુ ઓબ્જેક્ટ્સ એકબીજાનો સંદર્ભ આપે છે, તો તેમના રેફરન્સ કાઉન્ટ્સ ક્યારેય શૂન્ય સુધી પહોંચશે નહીં, ભલે તેઓ પ્રોગ્રામના બાકીના ભાગમાંથી પહોંચી શકાય તેવા ન હોય, જેના કારણે મેમરી લીક્સ થાય છે.
• જટિલતા: રેફરન્સ કાઉન્ટિંગનો યોગ્ય રીતે અમલ કરવો, ખાસ કરીને મલ્ટિથ્રેડેડ વાતાવરણમાં, રેસ કન્ડિશન ટાળવા અને સચોટ રેફરન્સ કાઉન્ટ્સ સુનિશ્ચિત કરવા માટે સાવચેતીપૂર્વક સિંક્રોનાઇઝેશનની જરૂર પડે છે. આ અમલીકરણમાં જટિલતા ઉમેરી શકે છે.

સર્ક્યુલર રેફરન્સ સમસ્યા

સર્ક્યુલર રેફરન્સ સમસ્યા એ અણઘડ રેફરન્સ કાઉન્ટિંગની એચિલીસ હીલ છે. બે ઓબ્જેક્ટ્સ, A અને B નો વિચાર કરો, જ્યાં A B નો સંદર્ભ આપે છે અને B A નો સંદર્ભ આપે છે. ભલે અન્ય કોઈ ઓબ્જેક્ટ A અથવા B નો સંદર્ભ ન આપતા હોય, તેમના રેફરન્સ કાઉન્ટ્સ ઓછામાં ઓછા એક હશે, તેમને ડીએલોકેટ થતાં અટકાવશે. આ મેમરી લીક બનાવે છે, કારણ કે A અને B દ્વારા કબજે કરેલી મેમરી ફાળવેલ પરંતુ પહોંચી ન શકાય તેવી રહે છે.

ઉદાહરણ: Python માં:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(1)
node2 = Node(2)

node1.next = node2
node2.next = node1  # સર્ક્યુલર રેફરન્સ બનાવવામાં આવ્યો

del node1
del node2  # મેમરી લીક: નોડ્સ હવે પહોંચી શકાય તેવા નથી, પરંતુ તેમના રેફરન્સ કાઉન્ટ હજુ પણ 1 છે

સ્માર્ટ પોઇન્ટર્સ (દા.ત., `std::shared_ptr`) નો ઉપયોગ કરતા C++ જેવી ભાષાઓ પણ આ વર્તણૂક દર્શાવી શકે છે જો કાળજીપૂર્વક સંચાલિત ન કરવામાં આવે. `shared_ptr` ના ચક્રો ડીએલોકેશનને અટકાવશે.

સાયક્લિક ગાર્બેજ કલેક્શન વ્યૂહરચનાઓ

સર્ક્યુલર રેફરન્સ સમસ્યાને હલ કરવા માટે, રેફરન્સ કાઉન્ટિંગ સિસ્ટમ સાથે સંયોજનમાં અનેક સાયક્લિક ગાર્બેજ કલેક્શન તકનીકોનો ઉપયોગ કરી શકાય છે. આ તકનીકો પહોંચી ન શકાય તેવા ઓબ્જેક્ટ્સના ચક્રોને ઓળખવા અને તોડવાનું લક્ષ્ય રાખે છે, તેમને ડીએલોકેટ કરવાની મંજૂરી આપે છે.

1. માર્ક અને સ્વીપ અલ્ગોરિધમ

માર્ક અને સ્વીપ અલ્ગોરિધમ એ વ્યાપકપણે ઉપયોગમાં લેવાતી ગાર્બેજ કલેક્શન તકનીક છે જેને રેફરન્સ કાઉન્ટિંગ સિસ્ટમ્સમાં સાયક્લિક રેફરન્સને હેન્ડલ કરવા માટે અનુકૂળ બનાવી શકાય છે. તેમાં બે તબક્કાઓ શામેલ છે:

• માર્ક તબક્કો: મૂળ ઓબ્જેક્ટ્સના સેટ (પ્રોગ્રામથી સીધા સુલભ ઓબ્જેક્ટ્સ) થી શરૂ કરીને, અલ્ગોરિધમ ઓબ્જેક્ટ ગ્રાફને ટ્રાવર્સ કરે છે, બધા પહોંચી શકાય તેવા ઓબ્જેક્ટ્સને માર્ક કરે છે.
• સ્વીપ તબક્કો: માર્કિંગ તબક્કા પછી, અલ્ગોરિધમ સમગ્ર મેમરી સ્પેસને સ્કેન કરે છે, માર્ક ન કરાયેલા ઓબ્જેક્ટ્સને ઓળખે છે. આ માર્ક ન કરાયેલા ઓબ્જેક્ટ્સ પહોંચી ન શકાય તેવા ગણવામાં આવે છે અને ડીએલોકેટ થાય છે.

રેફરન્સ કાઉન્ટિંગના સંદર્ભમાં, માર્ક અને સ્વીપ અલ્ગોરિધમનો ઉપયોગ પહોંચી ન શકાય તેવા ઓબ્જેક્ટ્સના ચક્રોને ઓળખવા માટે કરી શકાય છે. અલ્ગોરિધમ અસ્થાયી રૂપે બધા ઓબ્જેક્ટ્સના રેફરન્સ કાઉન્ટ્સને શૂન્ય પર સેટ કરે છે અને પછી માર્કિંગ તબક્કો કરે છે. જો માર્કિંગ તબક્કા પછી ઓબ્જેક્ટનો રેફરન્સ કાઉન્ટ શૂન્ય રહે છે, તો તેનો અર્થ એ છે કે ઓબ્જેક્ટ કોઈ પણ મૂળ ઓબ્જેક્ટ્સથી પહોંચી શકાય તેવો નથી અને તે પહોંચી ન શકાય તેવા ચક્રનો ભાગ છે.

અમલીકરણ ધ્યાનમાં રાખવા જેવી બાબતો:

• માર્ક અને સ્વીપ અલ્ગોરિધમને સમયાંતરે અથવા જ્યારે મેમરી વપરાશ ચોક્કસ થ્રેશોલ્ડ સુધી પહોંચે ત્યારે ટ્રિગર કરી શકાય છે.
• અનંત લૂપ્સ ટાળવા માટે માર્કિંગ તબક્કા દરમિયાન સર્ક્યુલર રેફરન્સને કાળજીપૂર્વક હેન્ડલ કરવું મહત્વપૂર્ણ છે.
• અલ્ગોરિધમ એપ્લિકેશન એક્ઝેક્યુશનમાં વિરામ દાખલ કરી શકે છે, ખાસ કરીને સ્વીપ તબક્કા દરમિયાન.

2. સાયક્લ ડિટેક્શન અલ્ગોરિધમ્સ

ઓબ્જેક્ટ ગ્રાફમાં ચક્રો ઓળખવા માટે ઘણા વિશિષ્ટ અલ્ગોરિધમ્સ ડિઝાઇન કરવામાં આવ્યા છે. આ અલ્ગોરિધમ્સનો ઉપયોગ રેફરન્સ કાઉન્ટિંગ સિસ્ટમ્સમાં પહોંચી ન શકાય તેવા ઓબ્જેક્ટ્સના ચક્રોને ઓળખવા માટે કરી શકાય છે.

a) ટાર્જનનું સ્ટ્રોંગલી કનેક્ટેડ કોમ્પોનન્ટ્સ અલ્ગોરિધમ

ટાર્જનનું અલ્ગોરિધમ એ ગ્રાફ ટ્રાવર્સલ અલ્ગોરિધમ છે જે નિર્દેશિત ગ્રાફમાં સ્ટ્રોંગલી કનેક્ટેડ કોમ્પોનન્ટ્સ (SCCs) ને ઓળખે છે. SCC એ એક સબગ્રાફ છે જ્યાં દરેક શિરોબિંદુ દરેક અન્ય શિરોબિંદુથી પહોંચી શકાય તેવું છે. ગાર્બેજ કલેક્શનના સંદર્ભમાં, SCCs ઓબ્જેક્ટ્સના ચક્રોનું પ્રતિનિધિત્વ કરી શકે છે.

તે કેવી રીતે કાર્ય કરે છે:

• અલ્ગોરિધમ ઓબ્જેક્ટ ગ્રાફનું ડેપ્થ-ફર્સ્ટ સર્ચ (DFS) કરે છે.
• DFS દરમિયાન, દરેક ઓબ્જેક્ટને એક અનન્ય ઇન્ડેક્સ અને લોલિંક મૂલ્ય સોંપવામાં આવે છે.
• લોલિંક મૂલ્ય વર્તમાન ઓબ્જેક્ટથી પહોંચી શકાય તેવા કોઈપણ ઓબ્જેક્ટનું સૌથી નાનું ઇન્ડેક્સ રજૂ કરે છે.
• જ્યારે DFS સ્ટેક પર પહેલેથી જ હોય ​​તેવા ઓબ્જેક્ટનો સામનો કરે છે, ત્યારે તે વર્તમાન ઓબ્જેક્ટના લોલિંક મૂલ્યને અપડેટ કરે છે.
• જ્યારે DFS SCC ની પ્રક્રિયા પૂર્ણ કરે છે, ત્યારે તે સ્ટેકમાંથી SCC ના તમામ ઓબ્જેક્ટ્સને પોપ કરે છે અને તેમને ચક્રના ભાગ રૂપે ઓળખે છે.

b) પાથ-આધારિત સ્ટ્રોંગ કોમ્પોનન્ટ અલ્ગોરિધમ

પાથ-આધારિત સ્ટ્રોંગ કોમ્પોનન્ટ અલ્ગોરિધમ (PBSCA) એ નિર્દેશિત ગ્રાફમાં SCCs ઓળખવા માટેનું અન્ય અલ્ગોરિધમ છે. તે સામાન્ય રીતે ટાર્જનના અલ્ગોરિધમ કરતાં વ્યવહારમાં વધુ કાર્યક્ષમ છે, ખાસ કરીને સ્પાર્સ ગ્રાફ્સ માટે.

તે કેવી રીતે કાર્ય કરે છે:

• અલ્ગોરિધમ DFS દરમિયાન મુલાકાત લીધેલા ઓબ્જેક્ટ્સનો સ્ટેક જાળવી રાખે છે.
• દરેક ઓબ્જેક્ટ માટે, તે રૂટ ઓબ્જેક્ટથી વર્તમાન ઓબ્જેક્ટ સુધીના પાથને સંગ્રહિત કરે છે.
• જ્યારે અલ્ગોરિધમ સ્ટેક પર પહેલેથી જ હોય ​​તેવા ઓબ્જેક્ટનો સામનો કરે છે, ત્યારે તે વર્તમાન ઓબ્જેક્ટના પાથની સ્ટેક પરના ઓબ્જેક્ટના પાથ સાથે તુલના કરે છે.
• જો વર્તમાન ઓબ્જેક્ટનો પાથ સ્ટેક પરના ઓબ્જેક્ટના પાથનો પૂર્વગામી હોય, તો તેનો અર્થ એ છે કે વર્તમાન ઓબ્જેક્ટ ચક્રનો ભાગ છે.

3. વિલંબિત રેફરન્સ કાઉન્ટિંગ

વિલંબિત રેફરન્સ કાઉન્ટિંગનો ઉદ્દેશ્ય રેફરન્સ કાઉન્ટ્સમાં વધારો અને ઘટાડોના ઓવરહેડને ઘટાડવાનો છે, આ કામગીરીઓને પછીના સમય સુધી મુલતવી રાખીને. આ રેફરન્સ કાઉન્ટ ફેરફારોને બફર કરીને અને તેમને બેચમાં લાગુ કરીને પ્રાપ્ત કરી શકાય છે.

તકનીકો:

• થ્રેડ-લોકલ બફર્સ: દરેક થ્રેડ રેફરન્સ કાઉન્ટ ફેરફારોને સંગ્રહિત કરવા માટે સ્થાનિક બફર જાળવી રાખે છે. આ ફેરફારો સમયાંતરે અથવા જ્યારે બફર ભરાઈ જાય ત્યારે વૈશ્વિક રેફરન્સ કાઉન્ટ્સ પર લાગુ કરવામાં આવે છે.
• રાઈટ બેરિયર્સ: ઓબ્જેક્ટ ફિલ્ડ્સ પર લખેલી કામગીરીને અટકાવવા માટે રાઈટ બેરિયર્સનો ઉપયોગ થાય છે. જ્યારે લખવાની કામગીરી નવો સંદર્ભ બનાવે છે, ત્યારે રાઈટ બેરિયર લખવાનું અટકાવે છે અને રેફરન્સ કાઉન્ટમાં વધારો મુલતવી રાખે છે.

જ્યારે વિલંબિત રેફરન્સ કાઉન્ટિંગ ઓવરહેડ ઘટાડી શકે છે, તે મેમરીની પુનઃપ્રાપ્તિને પણ વિલંબિત કરી શકે છે, સંભવિતપણે મેમરી વપરાશમાં વધારો કરી શકે છે.

4. આંશિક માર્ક અને સ્વીપ

સમગ્ર મેમરી સ્પેસ પર સંપૂર્ણ માર્ક અને સ્વીપ કરવાને બદલે, આંશિક માર્ક અને સ્વીપ મેમરીના નાના પ્રદેશ પર કરી શકાય છે, જેમ કે ચોક્કસ ઓબ્જેક્ટ અથવા ઓબ્જેક્ટ્સના જૂથથી પહોંચી શકાય તેવા ઓબ્જેક્ટ્સ. આ ગાર્બેજ કલેક્શન સાથે સંકળાયેલા વિરામ સમય ઘટાડી શકે છે.

અમલીકરણ:

• અલ્ગોરિધમ શંકાસ્પદ ઓબ્જેક્ટ્સના સેટ (ચક્રનો ભાગ હોવાની સંભાવના ધરાવતા ઓબ્જેક્ટ્સ) થી શરૂ થાય છે.
• તે આ ઓબ્જેક્ટ્સથી પહોંચી શકાય તેવા ઓબ્જેક્ટ ગ્રાફને ટ્રાવર્સ કરે છે, બધા પહોંચી શકાય તેવા ઓબ્જેક્ટ્સને માર્ક કરે છે.
• પછી તે માર્ક કરેલા પ્રદેશને સ્વીપ કરે છે, કોઈપણ માર્ક ન કરાયેલા ઓબ્જેક્ટ્સને ડીએલોકેટ કરે છે.

વિવિધ ભાષાઓમાં સાયક્લિક ગાર્બેજ કલેક્શનનો અમલ

પ્રોગ્રામિંગ ભાષા અને અંતર્ગત મેમરી મેનેજમેન્ટ સિસ્ટમ પર આધાર રાખીને સાયક્લિક ગાર્બેજ કલેક્શનનો અમલ બદલાઈ શકે છે. અહીં કેટલાક ઉદાહરણો છે:

Python

Python મેમરી મેનેજ કરવા માટે રેફરન્સ કાઉન્ટિંગ અને ટ્રેસિંગ ગાર્બેજ કલેક્ટરના સંયોજનનો ઉપયોગ કરે છે. રેફરન્સ કાઉન્ટિંગ ઘટક ઓબ્જેક્ટ્સના તાત્કાલિક ડીએલોકેશનને હેન્ડલ કરે છે, જ્યારે ટ્રેસિંગ ગાર્બેજ કલેક્ટર પહોંચી ન શકાય તેવા ઓબ્જેક્ટ્સના ચક્રોને શોધી અને તોડી નાખે છે.

Python માં ગાર્બેજ કલેક્ટર `gc` મોડ્યુલમાં અમલમાં મૂકવામાં આવે છે. તમે મેન્યુઅલી ગાર્બેજ કલેક્શન ટ્રિગર કરવા માટે `gc.collect()` ફંક્શનનો ઉપયોગ કરી શકો છો. ગાર્બેજ કલેક્ટર નિયમિત અંતરાલે આપમેળે પણ ચાલે છે.

ઉદાહરણ:

import gc

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(1)
node2 = Node(2)

node1.next = node2
node2.next = node1  # સર્ક્યુલર રેફરન્સ બનાવવામાં આવ્યો

del node1
del node2

gc.collect()  # ચક્ર તોડવા માટે ગાર્બેજ કલેક્શનને ફોર્સ કરો

C++

C++ માં બિલ્ટ-ઇન ગાર્બેજ કલેક્શન નથી. મેમરી મેનેજમેન્ટ સામાન્ય રીતે `new` અને `delete` નો ઉપયોગ કરીને મેન્યુઅલી અથવા સ્માર્ટ પોઇન્ટર્સનો ઉપયોગ કરીને હેન્ડલ કરવામાં આવે છે.

C++ માં સાયક્લિક ગાર્બેજ કલેક્શનનો અમલ કરવા માટે, તમે સાયક્લ ડિટેક્શન સાથે સ્માર્ટ પોઇન્ટર્સનો ઉપયોગ કરી શકો છો. એક અભિગમ `std::weak_ptr` નો ઉપયોગ કરીને ચક્રો તોડવાનો છે. `weak_ptr` એ સ્માર્ટ પોઇન્ટર છે જે તે જે ઓબ્જેક્ટને નિર્દેશ કરે છે તેના રેફરન્સ કાઉન્ટમાં વધારો કરતું નથી. આ તમને ઓબ્જેક્ટ્સના ચક્રો બનાવવાની મંજૂરી આપે છે તેમને ડીએલોકેટ થવાથી અટકાવ્યા વિના.

ઉદાહરણ:

#include 
#include 

class Node {
public:
    int data;
    std::shared_ptr next;
    std::weak_ptr prev;  // ચક્રો તોડવા માટે weak_ptr નો ઉપયોગ કરો

    Node(int data) : data(data) {}
    ~Node() { std::cout << "Node destroyed with data: " << data << std::endl; }
};

int main() {
    std::shared_ptr node1 = std::make_shared(1);
    std::shared_ptr node2 = std::make_shared(2);

    node1->next = node2;
    node2->prev = node1; // ચક્ર બનાવવામાં આવ્યું છે, પરંતુ prev weak_ptr છે

    node2.reset();
    node1.reset(); // નોડ્સ હવે નાશ પામશે

    return 0;
}

આ ઉદાહરણમાં, `node2` માં `node1` નો `weak_ptr` છે. જ્યારે `node1` અને `node2` બંને સ્કોપની બહાર જાય છે, ત્યારે તેમના શેર કરેલા પોઇન્ટર્સ નાશ પામે છે, અને નબળા પોઇન્ટર રેફરન્સ કાઉન્ટમાં ફાળો આપતું નથી કારણ કે ઓબ્જેક્ટ્સ ડીએલોકેટ થાય છે.

Java

Java એક ઓટોમેટિક ગાર્બેજ કલેક્ટરનો ઉપયોગ કરે છે જે આંતરિક રીતે ટ્રેસિંગ અને રેફરન્સ કાઉન્ટિંગના કેટલાક સ્વરૂપો બંનેને હેન્ડલ કરે છે. ગાર્બેજ કલેક્ટર સર્ક્યુલર રેફરન્સમાં સામેલ ઓબ્જેક્ટ્સ સહિત પહોંચી ન શકાય તેવા ઓબ્જેક્ટ્સને શોધી અને પુનઃપ્રાપ્ત કરવા માટે જવાબદાર છે. તમારે સામાન્ય રીતે Java માં સ્પષ્ટપણે સાયક્લિક ગાર્બેજ કલેક્શનનો અમલ કરવાની જરૂર નથી.

જોકે, ગાર્બેજ કલેક્ટર કેવી રીતે કાર્ય કરે છે તે સમજવું તમને વધુ કાર્યક્ષમ કોડ લખવામાં મદદ કરી શકે છે. તમે ગાર્બેજ કલેક્શન પ્રવૃત્તિ પર નજર રાખવા અને સંભવિત મેમરી લીક્સને ઓળખવા માટે પ્રોફાઇલર જેવા સાધનોનો ઉપયોગ કરી શકો છો.

JavaScript

JavaScript મેમરી મેનેજ કરવા માટે ગાર્બેજ કલેક્શન (ઘણીવાર માર્ક-એન્ડ-સ્વીપ અલ્ગોરિધમ) પર આધાર રાખે છે. જ્યારે રેફરન્સ કાઉન્ટિંગ એન્જિન ઓબ્જેક્ટ્સને ટ્રેક કરે છે તે રીતે ભાગ છે, વિકાસકર્તાઓ ગાર્બેજ કલેક્શનને સીધા નિયંત્રિત કરતા નથી. એન્જિન ચક્રો શોધવા માટે જવાબદાર છે.

જોકે, અજાણતાં મોટા ઓબ્જેક્ટ ગ્રાફ બનાવવાથી સાવચેત રહો જે ગાર્બેજ કલેક્શન ચક્રોને ધીમું કરી શકે છે. જ્યારે ઓબ્જેક્ટ્સની જરૂર ન હોય ત્યારે તેમને સંદર્ભો તોડવાથી એન્જિનને મેમરી વધુ કાર્યક્ષમ રીતે પુનઃપ્રાપ્ત કરવામાં મદદ મળે છે.

રેફરન્સ કાઉન્ટિંગ અને સાયક્લિક ગાર્બેજ કલેક્શન માટે શ્રેષ્ઠ પદ્ધતિઓ

• સર્ક્યુલર રેફરન્સ ઓછા કરો: સર્ક્યુલર રેફરન્સ બનાવટને ઘટાડવા માટે તમારી ડેટા સ્ટ્રક્ચર્સ ડિઝાઇન કરો. ચક્રોને સંપૂર્ણપણે ટાળવા માટે વૈકલ્પિક ડેટા સ્ટ્રક્ચર્સ અથવા તકનીકોનો વિચાર કરો.
• નબળા સંદર્ભોનો ઉપયોગ કરો: નબળા સંદર્ભોને સમર્થન આપતી ભાષાઓમાં, ચક્રો તોડવા માટે તેનો ઉપયોગ કરો. નબળા સંદર્ભો તે જે ઓબ્જેક્ટને નિર્દેશ કરે છે તેના રેફરન્સ કાઉન્ટમાં વધારો કરતા નથી, ઓબ્જેક્ટને ચક્રનો ભાગ હોવા છતાં ડીએલોકેટ કરવાની મંજૂરી આપે છે.
• સાયક્લ ડિટેક્શનનો અમલ કરો: જો તમે બિલ્ટ-ઇન સાયક્લ ડિટેક્શન વિનાની ભાષામાં રેફરન્સ કાઉન્ટિંગનો ઉપયોગ કરી રહ્યાં છો, તો પહોંચી ન શકાય તેવા ઓબ્જેક્ટ્સના ચક્રોને ઓળખવા અને તોડવા માટે સાયક્લ ડિટેક્શન અલ્ગોરિધમનો અમલ કરો.
• મેમરી વપરાશનું નિરીક્ષણ કરો: સંભવિત મેમરી લીક્સ શોધવા માટે મેમરી વપરાશનું નિરીક્ષણ કરો. યોગ્ય રીતે ડીએલોકેટ ન થઈ રહેલા ઓબ્જેક્ટ્સને ઓળખવા માટે પ્રોફાઇલિંગ સાધનોનો ઉપયોગ કરો.
• રેફરન્સ કાઉન્ટિંગ કામગીરીને ઓપ્ટિમાઇઝ કરો: ઓવરહેડ ઘટાડવા માટે રેફરન્સ કાઉન્ટિંગ કામગીરીને ઓપ્ટિમાઇઝ કરો. પ્રદર્શન સુધારવા માટે વિલંબિત રેફરન્સ કાઉન્ટિંગ અથવા રાઈટ બેરિયર જેવી તકનીકોનો વિચાર કરો.
• વેપાર-બંધોને ધ્યાનમાં લો: રેફરન્સ કાઉન્ટિંગ અને અન્ય મેમરી મેનેજમેન્ટ તકનીકો વચ્ચેના વેપાર-બંધોનું મૂલ્યાંકન કરો. રેફરન્સ કાઉન્ટિંગ બધી એપ્લિકેશન્સ માટે શ્રેષ્ઠ પસંદગી ન હોઈ શકે. તમારા નિર્ણય લેતી વખતે રેફરન્સ કાઉન્ટિંગની જટિલતા, ઓવરહેડ અને મર્યાદાઓને ધ્યાનમાં લો.

નિષ્કર્ષ

રેફરન્સ કાઉન્ટિંગ એ એક મૂલ્યવાન મેમરી મેનેજમેન્ટ તકનીક છે જે તાત્કાલિક પુનઃપ્રાપ્તિ અને સરળતા પ્રદાન કરે છે. જોકે, સર્ક્યુલર રેફરન્સને હેન્ડલ કરવામાં તેની અસમર્થતા એક નોંધપાત્ર મર્યાદા છે. માર્ક અને સ્વીપ અથવા સાયક્લ ડિટેક્શન અલ્ગોરિધમ્સ જેવી સાયક્લિક ગાર્બેજ કલેક્શન તકનીકોનો અમલ કરીને, તમે આ મર્યાદાને દૂર કરી શકો છો અને મેમરી લીક્સના જોખમ વિના રેફરન્સ કાઉન્ટિંગના ફાયદા મેળવી શકો છો. રેફરન્સ કાઉન્ટિંગ સાથે સંકળાયેલા વેપાર-બંધો અને શ્રેષ્ઠ પદ્ધતિઓને સમજવી મજબૂત અને કાર્યક્ષમ સોફ્ટવેર સિસ્ટમ્સ બનાવવા માટે નિર્ણાયક છે. તમારા એપ્લિકેશનની ચોક્કસ આવશ્યકતાઓને કાળજીપૂર્વક ધ્યાનમાં લો અને સર્ક્યુલર રેફરન્સના પડકારોને ઘટાડવા માટે જરૂરી હોય ત્યાં સાયક્લિક ગાર્બેજ કલેક્શનનો સમાવેશ કરીને, શ્રેષ્ઠ મેમરી મેનેજમેન્ટ વ્યૂહરચના પસંદ કરો. કાર્યક્ષમ મેમરી વપરાશ સુનિશ્ચિત કરવા અને સંભવિત મેમરી લીક્સને રોકવા માટે તમારા કોડને પ્રોફાઇલ અને ઓપ્ટિમાઇઝ કરવાનું યાદ રાખો.